OBJECTS

Python supports many different kinds of data

• 123, int
• 43.14159, float
• "Hello", string
• [1, 5, 7, 11, 13], List
• {"CA": "California", "MA": "Massachusetts"}, Dictonary

Each is an instance of an object, and every object has:

• a type
• an internal data representation (primitive or composite)
• a set of procedures for interaction with the object

Each instanceis a particular type of object

• 1234 is an instance of an int
• a = "hello" a is an instance of a string

OBJECT ORIENTED PROGRAMMING (OOP)

Everything in Python is an object and has a type

Objects are a data abstraction that capture:

• internal representation through data attributes
• interface for interacting with object through methods (procedures), defines behaviors but hides implementation

Can create new instances of objects

Can destroy objects

• explicitly using delor just “forget” about them
• Python system will reclaim destroyed or inaccessible objects –called “garbage collection”

ADVANTAGES OF OOP

Bundle data into packages together with procedures that work on them through well-defined interfaces

Divide-and-conquer development

• implement and test behavior of each class separately
• increased modularity reduces complexity

Classes make it easy to reuse code

• many Python modules define new classes
• each class has a separate environment (no collision on function names)
• inheritance allows subclasses to redefine or extend a selected subset of a superclass’ behavior

DEFINE YOUR OWN TYPES

Use the classkeyword to define a new type

class Coordinate(object): <br>

 - define attributes here

Similar to def, indent code to indicate which statements are part of the class definition

The word object means that Coordinateis a Python object and inherits all its attributes

• Coordinate is a subclass of object
• object is a superclass of Coordinate

WHAT ARE ATTRIBUTES?

Data and procedures that “belong” to the class

• data attributes

  • think of data as other objects that make up the class
  • for example, a coordinate is made up of two numbers

• procedural attributes (methods)

  • think of methods as functions that only work with this class
  • for example you can define a distance between two coordinate objects but there is no meaning to a distance between two list objects

class Coordinate(object):
    def __init__(self, x, y): # a special method called __init__to initialize some data attributes
        self.x = x
        self.y = y

c = Coordinate(3,4)
print(c)

<__main__.Coordinate object at 0x10e5dbbe0>

print(c.x)

3

origin = Coordinate(0,0)
origin.y

0

Data attributes of an instance are called instance variables

Don’t provide argument for self, Python does this automatically

class Coordinate(object):
    def __init__(self, x, y):
        self.x= x
        self.y= y
    def distance(self, other):
        x_diff_sq= (self.x-other.x)**2
        y_diff_sq= (self.y-other.y)**2
        return(x_diff_sq+y_diff_sq)**0.5

c = Coordinate(3,4)
origin = Coordinate(0,0)
c.distance(origin) # python by default realises c is an instance of a Coordinate

5.0

Coordinate.distance(c,origin) #another way of calling the same class

5.0

Python calls the str method when used with printon your class object

print(c) # prints some thing that dosen't make much sense 

<__main__.Coordinate object at 0x10e6805c0>

#adding __str__ method 
class Coordinate(object):
    def __init__(self, x, y):
        self.x= x
        self.y= y
    def distance(self, other):
        x_diff_sq= (self.x-other.x)**2
        y_diff_sq= (self.y-other.y)**2
        return(x_diff_sq+y_diff_sq)**0.5
    def __str__(self): #special method 
        return"<" + str(self.x) + "," + str(self.y) + ">"

c = Coordinate(3,4)
print(c) #prints as defined in __str__ method

<3,4>

print(isinstance(c, Coordinate)) # to check if an object is a Coordinate

True

#### Special predefined methods - __add__(self, other) self + other - __sub__(self, other) self -other - __eq__(self, other) self == other - __lt__(self, other) self < other - __len__(self) len(self) - __str__(self) print(self) ... and others

Example - 1

#Prints numbers in fraction format 

class fraction(object):
    def __init__(self, numer, denom):
        self.numer= numer
        self.denom= denom
    def __str__(self):
        return str(self.numer) + ' / ' + str(self.denom)

fraction(2,3)

<__main__.fraction at 0x10e68a048>

f = fraction(2,3)
print(f)

2 / 3

# Adding getters , getNumer and getDenom
# To sepearate the ineternal representation from external , simply put not to mess with original value.

class fraction(object):
    def __init__(self, numer, denom):
        self.numer= numer
        self.denom= denom
        
    def __str__(self):
        return str(self.numer) + ' / ' + str(self.denom)
    
    def getNumer(self):
        return self.numer
    
    def getDenom(self):
        return self.denom

f = fraction(2,3)
f.getNumer()

2

f.getDenom()

3

#Adding operations to fractions addition and subtraction.

class fraction(object):
    
    def __init__(self, numer, denom):
        self.numer= numer
        self.denom= denom
        
    def __str__(self):
        return str(self.numer) + ' / ' + str(self.denom)
    
    def getNumer(self):  # Getter methods are better practice than just accessing an attribute directly
        return self.numer
    
    def getDenom(self):
        return self.denom
    
    def __add__(self, other): # regular addition is replaced by this method 
        numerNew = other.getDenom() * self.getNumer() \
                    + other.getNumer() * self.getDenom()
        denomNew= other.getDenom() * self.getDenom()
        return fraction(numerNew, denomNew)

    def __sub__(self, other):# regular substration is replaced by this method 
        numerNew = other.getDenom() * self.getNumer() \
                    -other.getNumer() * self.getDenom()
        denomNew = other.getDenom() * self.getDenom()
        return fraction(numerNew, denomNew)
    
    def convert(self): #convert to decimal from fraction 
        return self.getNumer() / self.getDenom()

f = fraction(2,3)
g = fraction(4,5)

f.getNumer()

2

g.getDenom()

5

print(f + g)

22 / 15

print(f - g)

-2 / 15

f.convert()

0.6666666666666666

Example - 2

# a class to creat a list, check if member and remove from the list.

class intSet(object):
    
    def __init__(self):
        self.vals= []
    
    def insert(self, e):
        if not e in self.vals:
            self.vals.append(e)
            
    def member(self, e):
        return e in self.vals
    
    def remove(self, e):
        try:
            self.vals.remove(e)
        except:
            raise ValueError(str(e) + ' not found')
        
    def __str__(self):
        self.vals.sort()
        result = ''
        for e in self.vals:
            result = result + str(e) + ','
        return'{' + result[:-1] + '}'

a = intSet() 
a.member(3)

False

print(a)

{}

a.insert(3)

print(a)

{3}

a.insert(4)
a.insert(5)
a.insert(3) 

print(a) #note 3 is not repeated 

{3,4,5}

a.member(3)

True

a.member(5)

True

a.member(6)

False

print(a)

{3,4,5}

a.remove(3)

print(a)

{4,5}

a.remove(6) #Throws an error as expected 

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-64-f5eac6e57a25> in remove(self, e)
     16         try:
---> 17             self.vals.remove(e)
     18         except:

ValueError: list.remove(x): x not in list

During handling of the above exception, another exception occurred:

ValueError                                Traceback (most recent call last)
<ipython-input-77-b5608789f21a> in <module>()
----> 1 a.remove(6)

<ipython-input-64-f5eac6e57a25> in remove(self, e)
     17             self.vals.remove(e)
     18         except:
---> 19             raise ValueError(str(e) + ' not found')
     20 
     21     def __str__(self):

ValueError: 6 not found

__str__ and __repr__ <p>

The official Python documentation says __repr__ is used to compute the “official” string representation of an object and __str__ is used to compute the “informal” string representation of an object

import datetime
today = datetime.datetime.now()

str(today) # calls __str__ , readable 

'2018-08-05 06:52:41.933367'

repr(today) #calls __str__ , offical 

'datetime.datetime(2018, 8, 5, 6, 52, 41, 933367)'

eval('2018-08-05 06:52:41.933367') #str can not be reversed to datetime

Traceback (most recent call last):

  File "/anaconda3/lib/python3.6/site-packages/IPython/core/interactiveshell.py", line 2910, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)

  File "<ipython-input-163-5a248095457a>", line 1, in <module>
    eval('2018-08-05 06:52:41.933367')

  File "<string>", line 1
    2018-08-05 06:52:41.933367
          ^
SyntaxError: invalid token

eval('datetime.datetime(2018, 8, 5, 6, 52, 41, 933367)') #repr can , hence “official” string 

datetime.datetime(2018, 8, 5, 6, 52, 41, 933367)

Thus in a general every class you code must have a __repr__ and if you think it would be useful to have a string version of the object, as in the case of datetime create a __str__ function.

THE POWER OF OOP

• Bundle together objects that share

  • common attributes and
  • procedures that operate on those attributes

• Use abstraction to make a distinction between how to implement an object vs how to use the object

• Build layers of object abstractions that inherit behaviors from other classes of objects

• Create our own classes of objects on top of Python’s basic classes

CLASS DEFINITION INSTANCE OF AN OBJECT TYPE vs OF A CLASS

Class is the type

• a Coordinatetype
• class Coordinate(object):

Class is defined generically

• use self to refer to any instance while defining the class

Class defines data and methods common across all instances

Instance is one particular object

• mycoo= Coordinate(1,2)

Data values vary between instances

• c1 = Coordinate(1,2)
• c2 = Coordinate(3,4)
• C1 and c2 have different data values because they are different objects

instance has the structure of the class

class Animal(object):
    def __init__(self, age):
        self.age= age
        self.name= None
myanimal= Animal(3)

myanimal.age

3

myanimal.name

getters and setters should be used outside of class to access data attributes

class Animal(object):
    def __init__(self, age):
        self.age= age
        self.name= None
    def get_age(self):
        return self.age
    def get_name(self):
        return self.name
    def set_age(self, newage):
        self.age= newage
    def set_name(self, newname=""): #gives "" as default output
        self.name= newname
    def __str__(self):
        return "animal:"+str(self.name)+":"+str(self.age)

animal1 = Animal(10)

animal1.get_age()

10

animal1.get_name()

animal1.set_name("rocky")

animal1.get_name()

'rocky'

INFORMATION HIDING

Author of class definition may change data attribute variable names

If you are accessing data attributes outside the class and class definition changes, may get errors

Outside of class, use getters and setters instead

• use a.get_age()
• NOT a.age
• good style
• easy to maintain code
• prevents bugs

#example age is stored as year
class Animal(object):
    def __init__(self, age):
        self.years= age
    def get_age(self):
        return self.years

PYTHON NOT GREAT AT INFORMATION HIDING

Allows you to access data from outside class definition

• print(a.age)

Allows you to write to data from outside class definition

• a.age= 'infinite'

Allows you to create data attributes for an instance from outside class definition

• a.size= "tiny"

It’s not good style to do any of these!

HIERARCHIES

Parent class(superclass)

child class(subclass)

• inherits all data and behaviors of parent class
• add more info
• add more behavior
• override behavior

#regualr animal class as before
class Animal(object):
    def __init__(self, age):
        self.age= age
        self.name= None
    def get_age(self):
        return self.age
    def get_name(self):
        return self.name
    def set_age(self, newage):
        self.age= newage
    def set_name(self, newname=""): #gives "" as default output
        self.name= newname
    def __str__(self):
        return "animal:"+str(self.name)+":"+str(self.age)

# Cat sub class
class Cat(Animal):
    def speak(self):
        print("meow")
    def __str__(self):
        return "cat:"+str(self.name)+":"+str(self.age)

add new functionality with speak()

• instance of type Catcan be called with new methods
• instance of type Animalthrows error if called with new methods

__init__ is not missing, uses the Animal version

jelly = Cat(1)
jelly.set_name('JellyBelly')
print(jelly)

cat:JellyBelly:1

print(Animal.__str__(jelly)) #refrencing the parent class

animal:JellyBelly:1

# Another sub class

class Rabbit(Animal):
    def speak(self):
        print("meep")
    def __str__(self):
        return "rabbit: "+str(self.name)+":"+str(self.age)

jelly = Cat(1)
blob = Animal(1)
peter = Rabbit(5)
jelly.speak()

meow

peter.speak()

meep

blob.speak() #blob dosen't have attribute speak

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-200-0bdce68c74b6> in <module>()
----> 1 blob.speak() #blob dosen't have attribute speak

AttributeError: 'Animal' object has no attribute 'speak'

WHICH METHOD TO USE?

• subclass can have methods with same name as superclass
• subclass can have methods with same name as other subclasses
• for an instance of a class, look for a method name in current class definition
• if not found, look for method name up the hierarchy (in parent, then grandparent, and so on)
• use first method up the hierarchy that you found with that method name

#person subclass in Animal class
class Person(Animal):
    def __init__(self, name, age):
        Animal.__init__(self, age)
        Animal.set_name(self, name)
        self.friends= []
    def get_friends(self):
        return self.friends
    def add_friend(self, fname):
        if fname not in self.friends:
            self.friends.append(fname)
    def speak(self):
        print("hello")
    def age_diff(self, other):
        # alternate way: diff = self.age-other.age
        diff = self.get_age() -other.get_age()
        if self.age> other.age:
            print(self.name, "is", diff, "years older than", other.name)
        else:
            print(self.name, "is", -diff, "years younger than", other.name)
    def __str__(self):
        return "person:"+str(self.name)+":"+str(self.age)

eric= Person("Eric", 45)

john = Person("John", 55)

eric.speak()

hello

eric.age_diff(john)

Eric is 10 years younger than John

Person.age_diff(john,eric)

John is 10 years older than Eric

• sub classes inherit all data attributes and methods of the parent class

• tag used to give unique id to each new rabbit instance

class Rabbit(Animal):
    tag = 1
    def __init__(self, age, parent1=None, parent2=None):
        Animal.__init__(self, age)
        self.parent1 = parent1
        self.parent2 = parent2
        self.rid= Rabbit.tag
        Rabbit.tag += 1
    def get_rid(self):
        return str(self.rid).zfill(3)
    def get_parent1(self):
        return self.parent1
    def get_parent2(self):
        return self.parent2
    
    def __add__(self, other): #new add method
    # returning object of same type as this class
        return Rabbit(0, self, other)
    
    def __eq__(self, other): # comparing ids of parents since ids are unique
    #decide that two rabbits are equal if they have the same two parents
        parents_same = self.parent1.rid == other.parent1.rid \
        and self.parent2.rid == other.parent2.rid
        parents_opposite = self.parent2.rid == other.parent1.rid \
        and self.parent1.rid == other.parent2.rid
        return parents_same or parents_opposite

peter = Rabbit(2)
peter.set_name('Peter')
hopsy= Rabbit(3)
hopsy.set_name('Hopsy')
cotton = Rabbit(1, peter, hopsy)  # creats new instance with peter and hopsy as parents by calling the classs
cotton.set_name('Cottontail')
print(cotton)
print(cotton.get_parent1())

animal:Cottontail:1
animal:Peter:2

mopsy= peter + hopsy # creats new instance with peter and hopsy as parents  by additon operation
mopsy.set_name('Mopsy')
print(mopsy.get_parent1())
print(mopsy.get_parent2())

animal:Peter:2
animal:Hopsy:3

print(mopsy == cotton)

True

SUMMARY OF CLASSES & OOP

Bundle together objects that share

• common attributes and
• procedures that operate on those attributes

Use abstraction to make a distinction between how to implement an object vs how to use the object

Build layers of object abstractions that inherit behaviors from other classes of objects

create our own classes of objects on top of Python’s basic classes

---

Reference

• edX course offered by MIT
• 6.00.1x Introduction to Computer Science and Programming Using Python